home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / objtools / swcurve.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  4.9 KB  |  245 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  *    swcurve
  19.  *        sweep a curve to make a solid 
  20.  *
  21.  *            Paul Haeberli - 1990
  22.  */
  23. #include "math.h"
  24. #include "stdio.h"
  25. #include "sgiobj.h"
  26. #include "vect.h"
  27.  
  28. #define MAXPOINTS    1000
  29. #define MAXRUNS        100
  30.  
  31. int endpos[MAXPOINTS];
  32. float points[MAXPOINTS][3];
  33. int npoints;
  34. int flat = 0;
  35.  
  36. main(argc,argv)
  37. int argc;
  38. char **argv;
  39. {
  40.     int nsteps, npolys, nedges;
  41.     float angle;
  42.     vect n0, n1;
  43.     int p0;
  44.     sgiobj *obj;
  45.     float *dptr;
  46.  
  47.     if(argc<5) {
  48.     fprintf(stderr,"usage: swcurve in.cur out.bin nsteps angle [-f]\n");
  49.     exit(1);
  50.     }
  51.     if(argc>5)
  52.     flat = 1;
  53.     readpoints(argv[1]);
  54.     findruns();
  55.     nedges = npoints-1;
  56.  
  57.     nsteps = atoi(argv[3]); 
  58.     angle = atof(argv[4]); 
  59.     npolys = nsteps*nedges;
  60.  
  61.     obj = newquadobj(npolys);
  62.     dptr = (float *)obj->data;
  63.     for(p0=0; p0<nedges; p0++) {
  64.     if(endpos[p0]) 
  65.        setnormal2(&n0,p0,p0+1); 
  66.     else
  67.        setnormal3(&n0,p0-1,p0,p0+1); 
  68.      if(endpos[p0+1]) 
  69.        setnormal2(&n1,p0,p0+1);
  70.     else
  71.        setnormal3(&n1,p0,p0+1,p0+2);
  72.     dosweep(&n0,points+p0,&n1,points+p0+1,nsteps,angle,dptr);
  73.     dptr += 4*nsteps*PNTLONGS;
  74.     }
  75.     writesgiobj(argv[2],obj);
  76. }
  77.  
  78. dosweep(n0,p0,n1,p1,nsteps,angle,data)
  79. vect *n0,*p0,*n1,*p1;
  80. int nsteps;
  81. float angle;
  82. float *data;
  83. {
  84.     int i;
  85.     float a, s, c;
  86.     vect rn0, rp0, rn1, rp1;
  87.  
  88.     for(i=0; i<nsteps; i++) {
  89.     a = ((i+0.0)*angle)/nsteps;
  90.     s = sin(a*M_PI/180.0);
  91.     c = cos(a*M_PI/180.0);
  92.     vrot(p0,&rp0,s,c);
  93.     vrot(p1,&rp1,s,c);
  94.     if(flat) {
  95.         a = ((i+0.5)*angle)/nsteps;
  96.         s = sin(a*M_PI/180.0);
  97.         c = cos(a*M_PI/180.0);
  98.     }
  99.     vrot(n0,&rn0,s,c);
  100.     vrot(n1,&rn1,s,c);
  101.     copytodata(data,&rn0,&rp0,&rn1,&rp1);
  102.     a = ((i+1.0)*angle)/nsteps;
  103.     s = sin(a*M_PI/180.0);
  104.     c = cos(a*M_PI/180.0);
  105.     data += 2*PNTLONGS;
  106.     vrot(p0,&rp0,s,c);
  107.     vrot(p1,&rp1,s,c);
  108.     if(flat) {
  109.         a = ((i+0.5)*angle)/nsteps;
  110.         s = sin(a*M_PI/180.0);
  111.         c = cos(a*M_PI/180.0);
  112.     }
  113.     vrot(n0,&rn0,s,c);
  114.     vrot(n1,&rn1,s,c);
  115.     copytodata(data,&rn1,&rp1,&rn0,&rp0);
  116.     data += 2*PNTLONGS;
  117.     }
  118. }
  119.  
  120. vrot(p0,p1,s,c)
  121. vect *p0, *p1;
  122. float s, c;
  123. {
  124.     p1->x = s*p0->x + c*p0->z;
  125.     p1->y = p0->y;
  126.     p1->z = s*p0->z - c*p0->x;
  127. }
  128.  
  129. copytodata(data,n0,p0,n1,p1)
  130. float *data;
  131. float *n0,*p0,*n1,*p1;
  132. {
  133.     data[OFFSET_NORMAL+0] = n0[0];
  134.     data[OFFSET_NORMAL+1] = n0[1];
  135.     data[OFFSET_NORMAL+2] = n0[2];
  136.     data[OFFSET_POINT+0] = p0[0];
  137.     data[OFFSET_POINT+1] = p0[1];
  138.     data[OFFSET_POINT+2] = p0[2];
  139.     data += PNTLONGS;
  140.     data[OFFSET_NORMAL+0] = n1[0];
  141.     data[OFFSET_NORMAL+1] = n1[1];
  142.     data[OFFSET_NORMAL+2] = n1[2];
  143.     data[OFFSET_POINT+0] = p1[0];
  144.     data[OFFSET_POINT+1] = p1[1];
  145.     data[OFFSET_POINT+2] = p1[2];
  146. }
  147.  
  148. setnormal2(n,p0,p1)
  149. vect *n;
  150. {
  151.     n->x =  (points[p1][1]-points[p0][1]);
  152.     n->y = -(points[p1][0]-points[p0][0]);
  153.     n->z = 0.0;
  154.     vnormal(n);
  155. }
  156.  
  157. setnormal3(n,p0,p1,p2)
  158. vect *n;
  159. {
  160.     vect v0, v1, c;
  161.  
  162.     v0.x = points[p0][0]-points[p1][0];
  163.     v0.y = points[p0][1]-points[p1][1];
  164.     v0.z = 0.0;
  165.     vnormal(&v0);
  166.     v1.x = points[p2][0]-points[p1][0];
  167.     v1.y = points[p2][1]-points[p1][1];
  168.     v1.z = 0.0;
  169.     vnormal(&v1);
  170.     if(myvhalf(&v0,&v1,n)) {
  171.     vcross(n,&v0,&c);
  172.     if(c.z>0.0) {
  173.         n->x = -n->x;
  174.         n->y = -n->y;
  175.         n->z = -n->z;
  176.     }
  177.     } else {
  178.     setnormal2(n,p1,p2);
  179.     }
  180. }
  181.  
  182. myvhalf(v1,v2,half)
  183. vect *v1,*v2,*half;
  184. {
  185.    float len;
  186.  
  187.    vadd(v2,v1,half);
  188.    len = vlength(half);
  189.    if(len>0.001) {
  190.        vscale(half,1.0/len);
  191.        return 1;
  192.    } else
  193.        return 0;
  194. }
  195.  
  196. findruns()
  197. {
  198.     int i, dest;
  199.     float x, y;
  200.  
  201.     for(i=0; i<npoints; i++)
  202.     endpos[i] = 0;
  203.     dest = 0;
  204.     x = points[0][0];
  205.     y = points[0][1];
  206.     endpos[dest] = 1;
  207.     dest++;
  208.     for(i=1; i<npoints; i++) {
  209.     if(points[i][0] != x || points[i][1] != y) {
  210.         x = points[dest][0] = points[i][0];
  211.         y = points[dest][1] = points[i][1];
  212.         endpos[dest] = 0;
  213.         dest++;
  214.     } else {
  215.         endpos[dest-1] = 1;
  216.     }
  217.     }
  218.     endpos[dest-1] = 1;
  219.     npoints = dest;
  220. }
  221.  
  222. readpoints(name)
  223. char *name;
  224. {
  225.     FILE *inf;
  226.     int n, r;
  227.     float x, y;
  228.     char oneline[256];
  229.  
  230.     inf = fopen(name,"r");
  231.     if(!inf) {
  232.     fprintf(stderr,"can't open input file %s\n",name);
  233.     exit(1);
  234.     }
  235.     n = 0;
  236.     while(fgets(oneline,255,inf)) {
  237.     sscanf(oneline,"%f %f",&x,&y);
  238.     points[n][0] = x;
  239.     points[n][1] = y;
  240.     n++;
  241.     }
  242.     npoints = n;
  243.     fclose(inf);
  244. }
  245.